home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / Tools / glimpse-2.1 / index / getword.c < prev    next >
C/C++ Source or Header  |  1995-05-16  |  6KB  |  201 lines
  1. /* Copyright (c) 1994 Sun Wu, Udi Manber, Burra Gopal.  All Rights Reserved. */
  2. /* ./glimpse/index/getword.c */
  3. #include "glimpse.h"
  4.  
  5. extern int NextICurrentFileOffset, ICurrentFileOffset;
  6. int StructuredIndex = 0;
  7. int WORD_TOO_LONG = 0;
  8. int IndexNumber = 0;
  9. int CountWords = 0;
  10. int InterpretSpecial = 0;
  11. int indexable_char[256];
  12. int GMAX_WORD_SIZE = MAX_WORD_SIZE;
  13.  
  14. #define ALL_LOWER 0    /* default, what you start with: all are possible */
  15. #define FIRST_UPPER 1    /* only first one seen is upper: 0 is impossible */
  16. #define ALL_UPPER 2    /* all seen so far are upper: 2 and 3 are possible */
  17. #define MIXED 3        /* neither of the above 3 */
  18.  
  19. #define ALPHANUM 1
  20. #define ALPHAONLY 2
  21. #define NUMONLY 3
  22.  
  23. #define INDEXABLE(c)    (indexable_char[c])
  24.  
  25. /* -------------------------------------------------------------------------
  26. getword():
  27. get a word from stream pointed to by buffer.
  28. a word is a string of alpha-numeric characters.
  29. After the word is gotten, return a new pointer that points to a alpha-numeric
  30. character. For the first call to such function when the first character
  31. is not a alpha-numeric character, getword() only adjust the pointer to
  32. point to a alpha-numeric character.
  33. --------------------------------------------------------------------------*/
  34. unsigned char *getword(word, buffer, buffer_end, pattr)
  35. unsigned char *word;
  36. unsigned char *buffer;
  37. unsigned char *buffer_end;
  38. int *pattr;
  39. {
  40.     int  word_length=0;
  41.     unsigned char *wp=word;
  42.     unsigned char *old_buffer = buffer;
  43.     int    previslsq = 0;
  44.     int withinsq = 0;
  45.  
  46.     ICurrentFileOffset = NextICurrentFileOffset;
  47.     if (pattr != NULL) *pattr = 0;
  48.     if (CountWords) {    /* don't convert case, ignore special, don't bother about offsets. */
  49.     unsigned char *temp_buffer;
  50.     int flag = ALL_LOWER;
  51.  
  52.     for(temp_buffer = buffer; (temp_buffer - buffer < GMAX_WORD_SIZE) && (temp_buffer < buffer_end); temp_buffer ++) {
  53.         if (!INDEXABLE(*temp_buffer)) break;
  54.         if (isupper(*temp_buffer)) {
  55.         if (flag == ALL_LOWER) {
  56.             if (temp_buffer == buffer) flag = FIRST_UPPER;
  57.             else { flag = MIXED; break; }
  58.         }
  59.         else if (flag == FIRST_UPPER) {
  60.             if (temp_buffer == buffer + 1) flag = ALL_UPPER;
  61.             else { flag = MIXED; break; }
  62.         }
  63.         else continue;    /* must be ALL_UPPER -> let it remain so */
  64.         }
  65.         else if (islower(*temp_buffer)) {
  66.         if (flag == ALL_LOWER) continue;
  67.         else if (flag == FIRST_UPPER) continue;
  68.         else if (flag == ALL_UPPER) { flag = MIXED; break; }
  69.         }
  70.         /* else, not alphabet: ignore */
  71.     }
  72.  
  73.     if (flag == MIXED) {    /* discard mixed words since they cannot be indexed */
  74.         word[0] = '\0';
  75.         if (IndexNumber) while(isalnum(*temp_buffer++));
  76.         else while(isalpha(*temp_buffer++));
  77.         return temp_buffer;
  78.     }
  79.  
  80.     while(buffer < buffer_end) {
  81.         if(INDEXABLE(*buffer)) {
  82.          *word++ = *buffer ++;
  83.         word_length++;
  84.         }
  85.         else  {
  86.         while((buffer< buffer_end) && !(INDEXABLE(*buffer))) buffer++;
  87.         break;
  88.         }
  89.         if(word_length > GMAX_WORD_SIZE) {
  90.         word = wp;
  91.         WORD_TOO_LONG = ON;
  92.         while(INDEXABLE(*buffer)) buffer++; /* skip current long word */
  93.         break;
  94.         }    
  95.     }
  96.     }
  97.     else {    /* convert case, maybe interpret special */
  98.     while(buffer < buffer_end) {
  99.         if (INDEXABLE(*buffer)) {    /* ICurrentFileOffset is in the right place */
  100.         if (*buffer == '[') {
  101.             previslsq = 1;
  102.             withinsq = 1;
  103.         }
  104.         else {
  105.             previslsq = 0;
  106.             if (*buffer == ']') withinsq = 0;
  107.         }
  108.         if ((*buffer == '-') && !withinsq) {    /* terminate word here */
  109.             buffer ++;
  110.             ICurrentFileOffset ++;
  111.             break;
  112.         }
  113.         if (isupper(*buffer)) *word++ = tolower(*buffer++);
  114.         else *word++ = *buffer++;
  115.         word_length++;
  116.         }
  117.         else if (INDEXABLE('[') && (*buffer == '^') && previslsq) {
  118.         *word ++ = *buffer ++;
  119.         word_length ++;
  120.         previslsq = 0;
  121.         }
  122.         else {
  123.         previslsq = 0;
  124.         if (InterpretSpecial && (*buffer == '\\')) {
  125.             /* skip two things AND terminate word HERE */
  126.             if (buffer < buffer_end - 1) {
  127.             buffer += 2;
  128.             if (word_length <= 0) ICurrentFileOffset += 2;
  129.             }
  130.             else if (buffer < buffer_end) {
  131.             buffer ++;
  132.             if (word_length <= 0) ICurrentFileOffset ++;
  133.             }
  134.         }
  135.         else {
  136.             if (word_length <= 0) while((buffer < buffer_end) && !(INDEXABLE(*buffer))) {
  137.             ICurrentFileOffset ++;
  138.             buffer++;
  139.             }
  140.             else while((buffer < buffer_end) && !(INDEXABLE(*buffer))) buffer++;
  141.         }
  142.         break;
  143.         }
  144.  
  145.         if(word_length > GMAX_WORD_SIZE) {
  146.         word = wp;
  147.         WORD_TOO_LONG = ON;
  148.         while(INDEXABLE(*buffer)) buffer++; /* skip current long word */
  149.         break;
  150.         }    
  151.     }
  152.     }
  153.  
  154.     if(WORD_TOO_LONG) *wp = '\0';
  155.     *word = '\0';
  156.     WORD_TOO_LONG = 0;
  157.     if ((pattr != NULL) && (word_length > 0) && (StructuredIndex))
  158.     *pattr = region_identify(ICurrentFileOffset, 0);
  159.     NextICurrentFileOffset += (buffer <= old_buffer) ? 1 : (buffer - old_buffer);    /* beginning of next word, atleast 1 */
  160.     return(buffer);
  161. }
  162.  
  163. set_indexable_char(indexable_char)
  164.     int    indexable_char[256];
  165. {
  166.     int    i;
  167.  
  168.     /* Saves a lot of calls during run-time! */
  169.     for (i=0; i<256; i++) {
  170.         if(!isascii(i)) indexable_char[i] = 0;
  171.         else if(IndexNumber) indexable_char[i] = isalnum(i);
  172.         else indexable_char[i] = isalpha(i);
  173.     }
  174.     indexable_char['_'] = 1;
  175. }
  176.  
  177. set_special_char(special_char)
  178.     int    special_char[256];
  179. {
  180.     /*
  181.      * Set all special characters interpreted by agrep to 1.
  182.      * Assume set_indexable_char has been done on it.
  183.      */
  184.     special_char['-'] = 1;
  185.     /* special_char[','] = 1; */
  186.     /* special_char[';'] = 1; */
  187.     /* special_char['.'] = 1; */
  188.     /* special_char['#'] = 1; */
  189.     /* special_char['|'] = 1; */
  190.     special_char['['] = 1;
  191.     special_char[']'] = 1;
  192.     /* special_char['('] = 1; */
  193.     /* special_char[')'] = 1; */
  194.     /* special_char['>'] = 1; */
  195.     /* special_char['<'] = 1; */
  196.     /* special_char['^'] = 1; */
  197.     /* special_char['$'] = 1; */
  198.     /* special_char['+'] = 1; */
  199. }
  200.  
  201.